package com.hc.kotlin
    //-----变量:1 常量-----
const val variable = 5 //编译时常量,只能定义在函数外,只能是基本型
fun main1() {
    //-----:2 val-----
    val a:Int = 5 //不可修改变量
    println(a)
    //-----:3 var-----
    var b:Int= 100 //可修改变量
    println(b)
    //-----条件表达式:1 if else-----都建议改成when
    if(a>b){
        println("a>b")
    }else{
        println("a<=b")
    }
    //-----:2 范围-----含头且含尾
    if(b in 100..200){
        println("100-200")
    }else if(b in 0..100){
        println("0-100")
    }else{
        println("unknown")
    }
    if(b !in 0..100){
        println("not 0-100")
    }else{
        println("0-100")
    }
    //-----:3 when-----
    val rb = when (b) {
        100 -> "is 100"
        200 -> "is 200"
        else -> "unknown int"
    }
    println(rb)
    //-----String模板-----
    var c = "Jack"
    var d = "Rose"
    println("$c love $d")
    var e = true
    println("$c ${if (e) "love" else "not love"} $d")
    //-----函数-----
    println(f1(10000)) //有参有返回
    f2() //无参无返回
    println(f3()) //有参有默认值有返回
    f4(b=4,a="f4()") //有参具体指定值无返回
    `**no name function**`()//``函数
    Test.`f1`()//kotlin调用java
    //-----Nothing-----
    //TODO("no reason")//等价于java抛异常
}
fun main2(){
    //-----匿名函数-----{ l->l=='o'}
    val count = "Hello World".count({ l->
        l=='o'
    })
    println(count)
    val f:()->String={ //声明一个变量=无参匿名函数
        var a = "Hello"
        "World" //通常情况不写return 自动返回最后一行值
    }
    println(f) //返回函数本身
    println(f()) //返回函数执行结果
    val g:(Int)->Int={ a-> //有参匿名函数 参数类型写()中 参数名写{}中
        a+1
    }
    println(g(1))
    val h:(Int)->Int={ it //只有一个参数时,可用it代替参数名
        it+1
    }
    println(h(2))
    val h1 = {  //自动推断无参匿名函数的返回值
        4
    }
    println(h1)
    println(h1())
    val h2 = { name:Int,age:Int->  //自动推断参数类型
        name+age
    }
    println(h2(1,2))
    val h3 = { name:String,age:Int-> //自动推断参数类型
        name+age
    }
    println(h3("1",3))
}
fun main3(){
    val i = { it:Int->
        it*it
    }
    //-----参数是函数的函数-----
    i1(2,i)
    val count = "Hello".count {//参数只有一个lambda或最后一个是lambda,则可省略()
        it == 'l'
    }
    println(count)
}
fun main(){
    i1(5,::f1) //:: 函数引用
    println(f6()())
}
fun f6():()->String{
    var a = "Hello World f6()" //闭包形式:该函数又引用定义自身的函数的变量
    return { //返回一个函数
        a
    }
}
inline fun f5(){ //inline 内联函数 编译器直接复制粘贴代码至调用处

}
fun i1(a:Int,b:(Int)->Int){
    println(b(a))
}
private fun f1(a:Int):Int{
    return a
}
public fun f2(){
    println("f2()")
}
fun f3(a: Int = 1):Int{
    return a
}
fun f4(a:String,b:Int){
    println(a+b)
}
fun `**no name function**`(){
    println("i have not name")
}